package com.wutong.erb.other;

import lombok.Builder;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import java.util.HashMap;
import java.util.Map;

/**
 * 统一前端响应格式工具类，采用Builder模式构建标准化JSON响应
 *
 * <p>提供快速构建成功/失败响应、自定义HTTP状态码、扩展响应数据等功能</p>
 *
 * <h3>使用示例：</h3>
 * <pre>{@code
 * Response.success("登录成功")
 *     .data(user)
 *     .withHeaders("X-Custom-Header", "value")
 *     .ok();
 * }</pre>
 *
 * @author wutong
 * @see ResponseEntity
 */
@Slf4j
@Builder
@Getter
public class Response {
    /**
     * 操作状态标识：true-成功 / false-失败
     */
    private boolean status;
    /**
     * 给客户端的提示信息（支持i18n键值）
     */
    private String message;
    /**
     * 核心业务数据（可存储任意类型数据）
     */
    private Object data;
    /**
     * 自定义响应头存储容器（Key:头名称，Value:头值数组）
     */
    private final Map<String, String[]> headers = new HashMap<>();
    /**
     * 扩展数据容器（用于添加非标准字段）
     */
    private Map<String, Object> additionalData;

    /**
     * 将响应对象转换为Spring兼容的Map结构
     * @return 包含状态、消息、数据及扩展字段的Map对象
     */
    private Map<String, Object> toMap() {
        Map<String, Object> map = data == null ? Map.of("status", status, "message", message) : Map.of("status", status, "message", message, "data", data);
        Map<String, Object> result = new HashMap<>(map);
        if (additionalData != null) {
            result.putAll(additionalData);
        }
        return result;
    }

    /**
     * 构建成功响应（带附加数据）
     * @param message 提示信息（如："查询成功"）
     * @param additionalData 扩展数据（如统计信息）
     * @return 成功响应对象
     */
    public static Response success(String message, Map<String, Object> additionalData) {
        return Response.builder().status(true).message(message).additionalData(additionalData).build();
    }

    /**
     * 构建失败响应（快捷方式）
     * @param message 错误描述（如："参数校验失败"）
     * @return 失败响应对象
     */
    public static Response success(String message) {
        return Response.builder().status(true).message(message).build();
    }

    /**
     * 构建成功响应（快捷方式）
     * @return 成功响应对象
     */
    public static ResponseBuilder success() {
        return Response.builder().status(true);
    }

    /**
     * 构建失败响应（快捷方式）
     * @param message 错误描述（如："参数校验失败"）
     * @param additionalData 扩展数据（如错误详情）
     * @return 失败响应对象
     */
    public static Response failure(String message, Map<String, Object> additionalData) {
        return Response.builder().status(false).message(message).additionalData(additionalData).build();
    }

    /**
     * 构建失败响应（快捷方式）
     * @param message 错误描述（如："参数校验失败"）
     * @return 失败响应对象
     */
    public static Response failure(String message) {
        return Response.builder().status(false).message(message).build();
    }

    /**
     * 构建失败响应（快捷方式）
     * @return 失败响应对象
     */
    public static ResponseBuilder failure() {
        return Response.builder().status(false);
    }

    /**
     * 添加自定义响应头（支持链式调用）
     * @param headerName 头名称（如："Cache-Control"）
     * @param headerValue 头值数组（如："no-cache"）
     * @return 当前对象实例
     */
    public Response withHeaders(String headerName, String... headerValue) {
        headers.put(headerName, headerValue);
        return this;
    }

    /**
     * 构建响应对象（支持自定义HTTP状态码）
     * @param httpStatus HTTP状态码
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> buildResponseEntity(HttpStatus httpStatus) {
        ResponseEntity.BodyBuilder builder = ResponseEntity.status(httpStatus);
        if (headers.isEmpty()) {
            return builder.body(toMap());
        }
        for (Map.Entry<String, String[]> entry : headers.entrySet()) {
            builder.header(entry.getKey(), entry.getValue());
        }
        return builder.body(toMap());
    }

    /**
     * 构建200 OK响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> ok() {
        return buildResponseEntity(HttpStatus.OK);
    }

    /**
     * 构建201 Created响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> created() {
        return buildResponseEntity(HttpStatus.CREATED);
    }

    /**
     * 构建204 No Content响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> noContent() {
        return buildResponseEntity(HttpStatus.NO_CONTENT);
    }

    /**
     * 构建400 Bad Request响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> badRequest() {
        return buildResponseEntity(HttpStatus.BAD_REQUEST);
    }

    /**
     * 构建401 Unauthorized响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> unauthorized() {
        return buildResponseEntity(HttpStatus.UNAUTHORIZED);
    }

    /**
     * 构建403 Forbidden响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> forbidden() {
        return buildResponseEntity(HttpStatus.FORBIDDEN);
    }

    /**
     * 构建404 Not Found响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> notFound() {
        return buildResponseEntity(HttpStatus.NOT_FOUND);
    }

    /**
     * 构建405 Method Not Allowed响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> conflict() {
        return buildResponseEntity(HttpStatus.CONFLICT);
    }

    /**
     * 构建406 Not Acceptable响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> methodNotAllowed() {
        return buildResponseEntity(HttpStatus.METHOD_NOT_ALLOWED);
    }

    /**
     * 构建415 Unsupported Media Type响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> notAcceptable() {
        return buildResponseEntity(HttpStatus.NOT_ACCEPTABLE);
    }

    /**
     * 构建500 Internal Server Error响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> unsupportedMediaType() {
        return buildResponseEntity(HttpStatus.UNSUPPORTED_MEDIA_TYPE);
    }

    /**
     * 构建429 Too Many Requests响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> tooManyRequests() {
        return buildResponseEntity(HttpStatus.TOO_MANY_REQUESTS);
    }

    /**
     * 构建500 Internal Server Error响应
     * @return ResponseEntity对象
     */
    public ResponseEntity<?> internalServerError() {
        return buildResponseEntity(HttpStatus.INTERNAL_SERVER_ERROR);
    }
}
